home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / lib / gcc-lib / ppc-amigaos / 2.95.1 / sys-include / powerup / ppcpragmas / utility_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-03-13  |  22KB  |  752 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_UTILITY_H
  4. #define _PPCPRAGMA_UTILITY_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__UTILITY_H
  7. #include <powerup/ppcinline/utility.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef UTILITY_BASE_NAME
  24. #define UTILITY_BASE_NAME UtilityBase
  25. #endif /* !UTILITY_BASE_NAME */
  26.  
  27. #define    AddNamedObject(nameSpace, object)    _AddNamedObject(UTILITY_BASE_NAME, nameSpace, object)
  28.  
  29. static __inline BOOL
  30. _AddNamedObject(void *UtilityBase, struct NamedObject *nameSpace, struct NamedObject *object)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) nameSpace;
  40.     MyCaos.a1        =(ULONG) object;
  41.     MyCaos.caos_Un.Offset    =    (-222);
  42.     MyCaos.a6        =(ULONG) UtilityBase;    
  43.     return((BOOL)PPCCallOS(&MyCaos));
  44. }
  45.  
  46. #define    AllocNamedObjectA(name, tagList)    _AllocNamedObjectA(UTILITY_BASE_NAME, name, tagList)
  47.  
  48. static __inline struct NamedObject *
  49. _AllocNamedObjectA(void *UtilityBase, STRPTR name, struct TagItem *tagList)
  50. {
  51. struct Caos    MyCaos;
  52.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  53. //    MyCaos.M68kStart    =    NULL;
  54. //    MyCaos.M68kSize        =    0;
  55.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  56. //    MyCaos.PPCStart        =    NULL;
  57. //    MyCaos.PPCSize        =    0;
  58.     MyCaos.a0        =(ULONG) name;
  59.     MyCaos.a1        =(ULONG) tagList;
  60.     MyCaos.caos_Un.Offset    =    (-228);
  61.     MyCaos.a6        =(ULONG) UtilityBase;    
  62.     return((struct NamedObject *)PPCCallOS(&MyCaos));
  63. }
  64.  
  65. #ifndef NO_PPCINLINE_STDARG
  66. #define AllocNamedObject(a0, tags...) \
  67.     ({ULONG _tags[] = { tags }; AllocNamedObjectA((a0), (struct TagItem *)_tags);})
  68. #endif /* !NO_PPCINLINE_STDARG */
  69.  
  70. #define    AllocateTagItems(numTags)    _AllocateTagItems(UTILITY_BASE_NAME, numTags)
  71.  
  72. static __inline struct TagItem *
  73. _AllocateTagItems(void *UtilityBase, unsigned long numTags)
  74. {
  75. struct Caos    MyCaos;
  76.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  77. //    MyCaos.M68kStart    =    NULL;
  78. //    MyCaos.M68kSize        =    0;
  79.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  80. //    MyCaos.PPCStart        =    NULL;
  81. //    MyCaos.PPCSize        =    0;
  82.     MyCaos.d0        =(ULONG) numTags;
  83.     MyCaos.caos_Un.Offset    =    (-66);
  84.     MyCaos.a6        =(ULONG) UtilityBase;    
  85.     return((struct TagItem *)PPCCallOS(&MyCaos));
  86. }
  87.  
  88. #define    Amiga2Date(seconds, result)    _Amiga2Date(UTILITY_BASE_NAME, seconds, result)
  89.  
  90. static __inline void
  91. _Amiga2Date(void *UtilityBase, unsigned long seconds, struct ClockData *result)
  92. {
  93. struct Caos    MyCaos;
  94.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  95. //    MyCaos.M68kStart    =    NULL;
  96. //    MyCaos.M68kSize        =    0;
  97.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  98. //    MyCaos.PPCStart        =    NULL;
  99. //    MyCaos.PPCSize        =    0;
  100.     MyCaos.d0        =(ULONG) seconds;
  101.     MyCaos.a0        =(ULONG) result;
  102.     MyCaos.caos_Un.Offset    =    (-120);
  103.     MyCaos.a6        =(ULONG) UtilityBase;    
  104.     PPCCallOS(&MyCaos);
  105. }
  106.  
  107. #define    ApplyTagChanges(list, changeList)    _ApplyTagChanges(UTILITY_BASE_NAME, list, changeList)
  108.  
  109. static __inline void
  110. _ApplyTagChanges(void *UtilityBase, struct TagItem *list, struct TagItem *changeList)
  111. {
  112. struct Caos    MyCaos;
  113.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  114. //    MyCaos.M68kStart    =    NULL;
  115. //    MyCaos.M68kSize        =    0;
  116.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  117. //    MyCaos.PPCStart        =    NULL;
  118. //    MyCaos.PPCSize        =    0;
  119.     MyCaos.a0        =(ULONG) list;
  120.     MyCaos.a1        =(ULONG) changeList;
  121.     MyCaos.caos_Un.Offset    =    (-186);
  122.     MyCaos.a6        =(ULONG) UtilityBase;    
  123.     PPCCallOS(&MyCaos);
  124. }
  125.  
  126. #define    AttemptRemNamedObject(object)    _AttemptRemNamedObject(UTILITY_BASE_NAME, object)
  127.  
  128. static __inline LONG
  129. _AttemptRemNamedObject(void *UtilityBase, struct NamedObject *object)
  130. {
  131. struct Caos    MyCaos;
  132.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  133. //    MyCaos.M68kStart    =    NULL;
  134. //    MyCaos.M68kSize        =    0;
  135.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  136. //    MyCaos.PPCStart        =    NULL;
  137. //    MyCaos.PPCSize        =    0;
  138.     MyCaos.a0        =(ULONG) object;
  139.     MyCaos.caos_Un.Offset    =    (-234);
  140.     MyCaos.a6        =(ULONG) UtilityBase;    
  141.     return((LONG)PPCCallOS(&MyCaos));
  142. }
  143.  
  144. #define    CallHookPkt(hook, object, paramPacket)    _CallHookPkt(UTILITY_BASE_NAME, hook, object, paramPacket)
  145.  
  146. static __inline ULONG
  147. _CallHookPkt(void *UtilityBase, struct Hook *hook, APTR object, APTR paramPacket)
  148. {
  149. struct Caos    MyCaos;
  150.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  151. //    MyCaos.M68kStart    =    NULL;
  152. //    MyCaos.M68kSize        =    0;
  153.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  154. //    MyCaos.PPCStart        =    NULL;
  155. //    MyCaos.PPCSize        =    0;
  156.     MyCaos.a0        =(ULONG) hook;
  157.     MyCaos.a2        =(ULONG) object;
  158.     MyCaos.a1        =(ULONG) paramPacket;
  159.     MyCaos.caos_Un.Offset    =    (-102);
  160.     MyCaos.a6        =(ULONG) UtilityBase;    
  161.     return((ULONG)PPCCallOS(&MyCaos));
  162. }
  163.  
  164. #define    CheckDate(date)    _CheckDate(UTILITY_BASE_NAME, date)
  165.  
  166. static __inline ULONG
  167. _CheckDate(void *UtilityBase, struct ClockData *date)
  168. {
  169. struct Caos    MyCaos;
  170.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  171. //    MyCaos.M68kStart    =    NULL;
  172. //    MyCaos.M68kSize        =    0;
  173.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  174. //    MyCaos.PPCStart        =    NULL;
  175. //    MyCaos.PPCSize        =    0;
  176.     MyCaos.a0        =(ULONG) date;
  177.     MyCaos.caos_Un.Offset    =    (-132);
  178.     MyCaos.a6        =(ULONG) UtilityBase;    
  179.     return((ULONG)PPCCallOS(&MyCaos));
  180. }
  181.  
  182. #define    CloneTagItems(tagList)    _CloneTagItems(UTILITY_BASE_NAME, tagList)
  183.  
  184. static __inline struct TagItem *
  185. _CloneTagItems(void *UtilityBase, struct TagItem *tagList)
  186. {
  187. struct Caos    MyCaos;
  188.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  189. //    MyCaos.M68kStart    =    NULL;
  190. //    MyCaos.M68kSize        =    0;
  191.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  192. //    MyCaos.PPCStart        =    NULL;
  193. //    MyCaos.PPCSize        =    0;
  194.     MyCaos.a0        =(ULONG) tagList;
  195.     MyCaos.caos_Un.Offset    =    (-72);
  196.     MyCaos.a6        =(ULONG) UtilityBase;    
  197.     return((struct TagItem *)PPCCallOS(&MyCaos));
  198. }
  199.  
  200. #define    Date2Amiga(date)    _Date2Amiga(UTILITY_BASE_NAME, date)
  201.  
  202. static __inline ULONG
  203. _Date2Amiga(void *UtilityBase, struct ClockData *date)
  204. {
  205. struct Caos    MyCaos;
  206.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  207. //    MyCaos.M68kStart    =    NULL;
  208. //    MyCaos.M68kSize        =    0;
  209.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  210. //    MyCaos.PPCStart        =    NULL;
  211. //    MyCaos.PPCSize        =    0;
  212.     MyCaos.a0        =(ULONG) date;
  213.     MyCaos.caos_Un.Offset    =    (-126);
  214.     MyCaos.a6        =(ULONG) UtilityBase;    
  215.     return((ULONG)PPCCallOS(&MyCaos));
  216. }
  217.  
  218. #define    FilterTagChanges(changeList, originalList, apply)    _FilterTagChanges(UTILITY_BASE_NAME, changeList, originalList, apply)
  219.  
  220. static __inline void
  221. _FilterTagChanges(void *UtilityBase, struct TagItem *changeList, struct TagItem *originalList, unsigned long apply)
  222. {
  223. struct Caos    MyCaos;
  224.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  225. //    MyCaos.M68kStart    =    NULL;
  226. //    MyCaos.M68kSize        =    0;
  227.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  228. //    MyCaos.PPCStart        =    NULL;
  229. //    MyCaos.PPCSize        =    0;
  230.     MyCaos.a0        =(ULONG) changeList;
  231.     MyCaos.a1        =(ULONG) originalList;
  232.     MyCaos.d0        =(ULONG) apply;
  233.     MyCaos.caos_Un.Offset    =    (-54);
  234.     MyCaos.a6        =(ULONG) UtilityBase;    
  235.     PPCCallOS(&MyCaos);
  236. }
  237.  
  238. #define    FilterTagItems(tagList, filterArray, logic)    _FilterTagItems(UTILITY_BASE_NAME, tagList, filterArray, logic)
  239.  
  240. static __inline ULONG
  241. _FilterTagItems(void *UtilityBase, struct TagItem *tagList, Tag *filterArray, unsigned long logic)
  242. {
  243. struct Caos    MyCaos;
  244.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  245. //    MyCaos.M68kStart    =    NULL;
  246. //    MyCaos.M68kSize        =    0;
  247.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  248. //    MyCaos.PPCStart        =    NULL;
  249. //    MyCaos.PPCSize        =    0;
  250.     MyCaos.a0        =(ULONG) tagList;
  251.     MyCaos.a1        =(ULONG) filterArray;
  252.     MyCaos.d0        =(ULONG) logic;
  253.     MyCaos.caos_Un.Offset    =    (-96);
  254.     MyCaos.a6        =(ULONG) UtilityBase;    
  255.     return((ULONG)PPCCallOS(&MyCaos));
  256. }
  257.  
  258. #define    FindNamedObject(nameSpace, name, lastObject)    _FindNamedObject(UTILITY_BASE_NAME, nameSpace, name, lastObject)
  259.  
  260. static __inline struct NamedObject *
  261. _FindNamedObject(void *UtilityBase, struct NamedObject *nameSpace, STRPTR name, struct NamedObject *lastObject)
  262. {
  263. struct Caos    MyCaos;
  264.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  265. //    MyCaos.M68kStart    =    NULL;
  266. //    MyCaos.M68kSize        =    0;
  267.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  268. //    MyCaos.PPCStart        =    NULL;
  269. //    MyCaos.PPCSize        =    0;
  270.     MyCaos.a0        =(ULONG) nameSpace;
  271.     MyCaos.a1        =(ULONG) name;
  272.     MyCaos.a2        =(ULONG) lastObject;
  273.     MyCaos.caos_Un.Offset    =    (-240);
  274.     MyCaos.a6        =(ULONG) UtilityBase;    
  275.     return((struct NamedObject *)PPCCallOS(&MyCaos));
  276. }
  277.  
  278. #define    FindTagItem(tagVal, tagList)    _FindTagItem(UTILITY_BASE_NAME, tagVal, tagList)
  279.  
  280. static __inline struct TagItem *
  281. _FindTagItem(void *UtilityBase, Tag tagVal, struct TagItem *tagList)
  282. {
  283. struct Caos    MyCaos;
  284.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  285. //    MyCaos.M68kStart    =    NULL;
  286. //    MyCaos.M68kSize        =    0;
  287.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  288. //    MyCaos.PPCStart        =    NULL;
  289. //    MyCaos.PPCSize        =    0;
  290.     MyCaos.d0        =(ULONG) tagVal;
  291.     MyCaos.a0        =(ULONG) tagList;
  292.     MyCaos.caos_Un.Offset    =    (-30);
  293.     MyCaos.a6        =(ULONG) UtilityBase;    
  294.     return((struct TagItem *)PPCCallOS(&MyCaos));
  295. }
  296.  
  297. #define    FreeNamedObject(object)    _FreeNamedObject(UTILITY_BASE_NAME, object)
  298.  
  299. static __inline void
  300. _FreeNamedObject(void *UtilityBase, struct NamedObject *object)
  301. {
  302. struct Caos    MyCaos;
  303.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  304. //    MyCaos.M68kStart    =    NULL;
  305. //    MyCaos.M68kSize        =    0;
  306.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  307. //    MyCaos.PPCStart        =    NULL;
  308. //    MyCaos.PPCSize        =    0;
  309.     MyCaos.a0        =(ULONG) object;
  310.     MyCaos.caos_Un.Offset    =    (-246);
  311.     MyCaos.a6        =(ULONG) UtilityBase;    
  312.     PPCCallOS(&MyCaos);
  313. }
  314.  
  315. #define    FreeTagItems(tagList)    _FreeTagItems(UTILITY_BASE_NAME, tagList)
  316.  
  317. static __inline void
  318. _FreeTagItems(void *UtilityBase, struct TagItem *tagList)
  319. {
  320. struct Caos    MyCaos;
  321.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  322. //    MyCaos.M68kStart    =    NULL;
  323. //    MyCaos.M68kSize        =    0;
  324.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  325. //    MyCaos.PPCStart        =    NULL;
  326. //    MyCaos.PPCSize        =    0;
  327.     MyCaos.a0        =(ULONG) tagList;
  328.     MyCaos.caos_Un.Offset    =    (-78);
  329.     MyCaos.a6        =(ULONG) UtilityBase;    
  330.     PPCCallOS(&MyCaos);
  331. }
  332.  
  333. #define    GetTagData(tagValue, defaultVal, tagList)    _GetTagData(UTILITY_BASE_NAME, tagValue, defaultVal, tagList)
  334.  
  335. static __inline ULONG
  336. _GetTagData(void *UtilityBase, Tag tagValue, unsigned long defaultVal, struct TagItem *tagList)
  337. {
  338. struct Caos    MyCaos;
  339.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  340. //    MyCaos.M68kStart    =    NULL;
  341. //    MyCaos.M68kSize        =    0;
  342.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  343. //    MyCaos.PPCStart        =    NULL;
  344. //    MyCaos.PPCSize        =    0;
  345.     MyCaos.d0        =(ULONG) tagValue;
  346.     MyCaos.d1        =(ULONG) defaultVal;
  347.     MyCaos.a0        =(ULONG) tagList;
  348.     MyCaos.caos_Un.Offset    =    (-36);
  349.     MyCaos.a6        =(ULONG) UtilityBase;    
  350.     return((ULONG)PPCCallOS(&MyCaos));
  351. }
  352.  
  353. #define    GetUniqueID()    _GetUniqueID(UTILITY_BASE_NAME)
  354.  
  355. static __inline ULONG
  356. _GetUniqueID(void *UtilityBase)
  357. {
  358. struct Caos    MyCaos;
  359.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  360. //    MyCaos.M68kStart    =    NULL;
  361. //    MyCaos.M68kSize        =    0;
  362.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  363. //    MyCaos.PPCStart        =    NULL;
  364. //    MyCaos.PPCSize        =    0;
  365.     MyCaos.caos_Un.Offset    =    (-270);
  366.     MyCaos.a6        =(ULONG) UtilityBase;    
  367.     return((ULONG)PPCCallOS(&MyCaos));
  368. }
  369.  
  370. #define    MapTags(tagList, mapList, mapType)    _MapTags(UTILITY_BASE_NAME, tagList, mapList, mapType)
  371.  
  372. static __inline void
  373. _MapTags(void *UtilityBase, struct TagItem *tagList, struct TagItem *mapList, unsigned long mapType)
  374. {
  375. struct Caos    MyCaos;
  376.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  377. //    MyCaos.M68kStart    =    NULL;
  378. //    MyCaos.M68kSize        =    0;
  379.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  380. //    MyCaos.PPCStart        =    NULL;
  381. //    MyCaos.PPCSize        =    0;
  382.     MyCaos.a0        =(ULONG) tagList;
  383.     MyCaos.a1        =(ULONG) mapList;
  384.     MyCaos.d0        =(ULONG) mapType;
  385.     MyCaos.caos_Un.Offset    =    (-60);
  386.     MyCaos.a6        =(ULONG) UtilityBase;    
  387.     PPCCallOS(&MyCaos);
  388. }
  389.  
  390. #define    NamedObjectName(object)    _NamedObjectName(UTILITY_BASE_NAME, object)
  391.  
  392. static __inline STRPTR
  393. _NamedObjectName(void *UtilityBase, struct NamedObject *object)
  394. {
  395. struct Caos    MyCaos;
  396.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  397. //    MyCaos.M68kStart    =    NULL;
  398. //    MyCaos.M68kSize        =    0;
  399.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  400. //    MyCaos.PPCStart        =    NULL;
  401. //    MyCaos.PPCSize        =    0;
  402.     MyCaos.a0        =(ULONG) object;
  403.     MyCaos.caos_Un.Offset    =    (-252);
  404.     MyCaos.a6        =(ULONG) UtilityBase;    
  405.     return((STRPTR)PPCCallOS(&MyCaos));
  406. }
  407.  
  408. #define    NextTagItem(tagListPtr)    _NextTagItem(UTILITY_BASE_NAME, tagListPtr)
  409.  
  410. static __inline struct TagItem *
  411. _NextTagItem(void *UtilityBase, struct TagItem **tagListPtr)
  412. {
  413. struct Caos    MyCaos;
  414.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  415. //    MyCaos.M68kStart    =    NULL;
  416. //    MyCaos.M68kSize        =    0;
  417.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  418. //    MyCaos.PPCStart        =    NULL;
  419. //    MyCaos.PPCSize        =    0;
  420.     MyCaos.a0        =(ULONG) tagListPtr;
  421.     MyCaos.caos_Un.Offset    =    (-48);
  422.     MyCaos.a6        =(ULONG) UtilityBase;    
  423.     return((struct TagItem *)PPCCallOS(&MyCaos));
  424. }
  425.  
  426. #define    PackBoolTags(initialFlags, tagList, boolMap)    _PackBoolTags(UTILITY_BASE_NAME, initialFlags, tagList, boolMap)
  427.  
  428. static __inline ULONG
  429. _PackBoolTags(void *UtilityBase, unsigned long initialFlags, struct TagItem *tagList, struct TagItem *boolMap)
  430. {
  431. struct Caos    MyCaos;
  432.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  433. //    MyCaos.M68kStart    =    NULL;
  434. //    MyCaos.M68kSize        =    0;
  435.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  436. //    MyCaos.PPCStart        =    NULL;
  437. //    MyCaos.PPCSize        =    0;
  438.     MyCaos.d0        =(ULONG) initialFlags;
  439.     MyCaos.a0        =(ULONG) tagList;
  440.     MyCaos.a1        =(ULONG) boolMap;
  441.     MyCaos.caos_Un.Offset    =    (-42);
  442.     MyCaos.a6        =(ULONG) UtilityBase;    
  443.     return((ULONG)PPCCallOS(&MyCaos));
  444. }
  445.  
  446. #define    PackStructureTags(pack, packTable, tagList)    _PackStructureTags(UTILITY_BASE_NAME, pack, packTable, tagList)
  447.  
  448. static __inline ULONG
  449. _PackStructureTags(void *UtilityBase, APTR pack, ULONG *packTable, struct TagItem *tagList)
  450. {
  451. struct Caos    MyCaos;
  452.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  453. //    MyCaos.M68kStart    =    NULL;
  454. //    MyCaos.M68kSize        =    0;
  455.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  456. //    MyCaos.PPCStart        =    NULL;
  457. //    MyCaos.PPCSize        =    0;
  458.     MyCaos.a0        =(ULONG) pack;
  459.     MyCaos.a1        =(ULONG) packTable;
  460.     MyCaos.a2        =(ULONG) tagList;
  461.     MyCaos.caos_Un.Offset    =    (-210);
  462.     MyCaos.a6        =(ULONG) UtilityBase;    
  463.     return((ULONG)PPCCallOS(&MyCaos));
  464. }
  465.  
  466. #define    RefreshTagItemClones(clone, original)    _RefreshTagItemClones(UTILITY_BASE_NAME, clone, original)
  467.  
  468. static __inline void
  469. _RefreshTagItemClones(void *UtilityBase, struct TagItem *clone, struct TagItem *original)
  470. {
  471. struct Caos    MyCaos;
  472.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  473. //    MyCaos.M68kStart    =    NULL;
  474. //    MyCaos.M68kSize        =    0;
  475.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  476. //    MyCaos.PPCStart        =    NULL;
  477. //    MyCaos.PPCSize        =    0;
  478.     MyCaos.a0        =(ULONG) clone;
  479.     MyCaos.a1        =(ULONG) original;
  480.     MyCaos.caos_Un.Offset    =    (-84);
  481.     MyCaos.a6        =(ULONG) UtilityBase;    
  482.     PPCCallOS(&MyCaos);
  483. }
  484.  
  485. #define    ReleaseNamedObject(object)    _ReleaseNamedObject(UTILITY_BASE_NAME, object)
  486.  
  487. static __inline void
  488. _ReleaseNamedObject(void *UtilityBase, struct NamedObject *object)
  489. {
  490. struct Caos    MyCaos;
  491.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  492. //    MyCaos.M68kStart    =    NULL;
  493. //    MyCaos.M68kSize        =    0;
  494.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  495. //    MyCaos.PPCStart        =    NULL;
  496. //    MyCaos.PPCSize        =    0;
  497.     MyCaos.a0        =(ULONG) object;
  498.     MyCaos.caos_Un.Offset    =    (-258);
  499.     MyCaos.a6        =(ULONG) UtilityBase;    
  500.     PPCCallOS(&MyCaos);
  501. }
  502.  
  503. #define    RemNamedObject(object, message)    _RemNamedObject(UTILITY_BASE_NAME, object, message)
  504.  
  505. static __inline void
  506. _RemNamedObject(void *UtilityBase, struct NamedObject *object, struct Message *message)
  507. {
  508. struct Caos    MyCaos;
  509.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  510. //    MyCaos.M68kStart    =    NULL;
  511. //    MyCaos.M68kSize        =    0;
  512.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  513. //    MyCaos.PPCStart        =    NULL;
  514. //    MyCaos.PPCSize        =    0;
  515.     MyCaos.a0        =(ULONG) object;
  516.     MyCaos.a1        =(ULONG) message;
  517.     MyCaos.caos_Un.Offset    =    (-264);
  518.     MyCaos.a6        =(ULONG) UtilityBase;    
  519.     PPCCallOS(&MyCaos);
  520. }
  521.  
  522. #define    SDivMod32(dividend, divisor)    _SDivMod32(UTILITY_BASE_NAME, dividend, divisor)
  523.  
  524. static __inline LONG
  525. _SDivMod32(void *UtilityBase, long dividend, long divisor)
  526. {
  527. struct Caos    MyCaos;
  528.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  529. //    MyCaos.M68kStart    =    NULL;
  530. //    MyCaos.M68kSize        =    0;
  531.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  532. //    MyCaos.PPCStart        =    NULL;
  533. //    MyCaos.PPCSize        =    0;
  534.     MyCaos.d0        =(ULONG) dividend;
  535.     MyCaos.d1        =(ULONG) divisor;
  536.     MyCaos.caos_Un.Offset    =    (-150);
  537.     MyCaos.a6        =(ULONG) UtilityBase;    
  538.     return((LONG)PPCCallOS(&MyCaos));
  539. }
  540.  
  541. #define    SMult32(arg1, arg2)    _SMult32(UTILITY_BASE_NAME, arg1, arg2)
  542.  
  543. static __inline LONG
  544. _SMult32(void *UtilityBase, long arg1, long arg2)
  545. {
  546. struct Caos    MyCaos;
  547.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  548. //    MyCaos.M68kStart    =    NULL;
  549. //    MyCaos.M68kSize        =    0;
  550.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  551. //    MyCaos.PPCStart        =    NULL;
  552. //    MyCaos.PPCSize        =    0;
  553.     MyCaos.d0        =(ULONG) arg1;
  554.     MyCaos.d1        =(ULONG) arg2;
  555.     MyCaos.caos_Un.Offset    =    (-138);
  556.     MyCaos.a6        =(ULONG) UtilityBase;    
  557.     return((LONG)PPCCallOS(&MyCaos));
  558. }
  559.  
  560. #define    SMult64(arg1, arg2)    _SMult64(UTILITY_BASE_NAME, arg1, arg2)
  561.  
  562. static __inline LONG
  563. _SMult64(void *UtilityBase, long arg1, long arg2)
  564. {
  565. struct Caos    MyCaos;
  566.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  567. //    MyCaos.M68kStart    =    NULL;
  568. //    MyCaos.M68kSize        =    0;
  569.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  570. //    MyCaos.PPCStart        =    NULL;
  571. //    MyCaos.PPCSize        =    0;
  572.     MyCaos.d0        =(ULONG) arg1;
  573.     MyCaos.d1        =(ULONG) arg2;
  574.     MyCaos.caos_Un.Offset    =    (-198);
  575.     MyCaos.a6        =(ULONG) UtilityBase;    
  576.     return((LONG)PPCCallOS(&MyCaos));
  577. }
  578.  
  579. #define    Stricmp(string1, string2)    _Stricmp(UTILITY_BASE_NAME, string1, string2)
  580.  
  581. static __inline LONG
  582. _Stricmp(void *UtilityBase, STRPTR string1, STRPTR string2)
  583. {
  584. struct Caos    MyCaos;
  585.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  586. //    MyCaos.M68kStart    =    NULL;
  587. //    MyCaos.M68kSize        =    0;
  588.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  589. //    MyCaos.PPCStart        =    NULL;
  590. //    MyCaos.PPCSize        =    0;
  591.     MyCaos.a0        =(ULONG) string1;
  592.     MyCaos.a1        =(ULONG) string2;
  593.     MyCaos.caos_Un.Offset    =    (-162);
  594.     MyCaos.a6        =(ULONG) UtilityBase;    
  595.     return((LONG)PPCCallOS(&MyCaos));
  596. }
  597.  
  598. #define    Strnicmp(string1, string2, length)    _Strnicmp(UTILITY_BASE_NAME, string1, string2, length)
  599.  
  600. static __inline LONG
  601. _Strnicmp(void *UtilityBase, STRPTR string1, STRPTR string2, long length)
  602. {
  603. struct Caos    MyCaos;
  604.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  605. //    MyCaos.M68kStart    =    NULL;
  606. //    MyCaos.M68kSize        =    0;
  607.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  608. //    MyCaos.PPCStart        =    NULL;
  609. //    MyCaos.PPCSize        =    0;
  610.     MyCaos.a0        =(ULONG) string1;
  611.     MyCaos.a1        =(ULONG) string2;
  612.     MyCaos.d0        =(ULONG) length;
  613.     MyCaos.caos_Un.Offset    =    (-168);
  614.     MyCaos.a6        =(ULONG) UtilityBase;    
  615.     return((LONG)PPCCallOS(&MyCaos));
  616. }
  617.  
  618. #define    TagInArray(tagValue, tagArray)    _TagInArray(UTILITY_BASE_NAME, tagValue, tagArray)
  619.  
  620. static __inline BOOL
  621. _TagInArray(void *UtilityBase, Tag tagValue, Tag *tagArray)
  622. {
  623. struct Caos    MyCaos;
  624.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  625. //    MyCaos.M68kStart    =    NULL;
  626. //    MyCaos.M68kSize        =    0;
  627.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  628. //    MyCaos.PPCStart        =    NULL;
  629. //    MyCaos.PPCSize        =    0;
  630.     MyCaos.d0        =(ULONG) tagValue;
  631.     MyCaos.a0        =(ULONG) tagArray;
  632.     MyCaos.caos_Un.Offset    =    (-90);
  633.     MyCaos.a6        =(ULONG) UtilityBase;    
  634.     return((BOOL)PPCCallOS(&MyCaos));
  635. }
  636.  
  637. #define    ToLower(character)    _ToLower(UTILITY_BASE_NAME, character)
  638.  
  639. static __inline UBYTE
  640. _ToLower(void *UtilityBase, unsigned long character)
  641. {
  642. struct Caos    MyCaos;
  643.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  644. //    MyCaos.M68kStart    =    NULL;
  645. //    MyCaos.M68kSize        =    0;
  646.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  647. //    MyCaos.PPCStart        =    NULL;
  648. //    MyCaos.PPCSize        =    0;
  649.     MyCaos.d0        =(ULONG) character;
  650.     MyCaos.caos_Un.Offset    =    (-180);
  651.     MyCaos.a6        =(ULONG) UtilityBase;    
  652.     return((UBYTE)PPCCallOS(&MyCaos));
  653. }
  654.  
  655. #define    ToUpper(character)    _ToUpper(UTILITY_BASE_NAME, character)
  656.  
  657. static __inline UBYTE
  658. _ToUpper(void *UtilityBase, unsigned long character)
  659. {
  660. struct Caos    MyCaos;
  661.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  662. //    MyCaos.M68kStart    =    NULL;
  663. //    MyCaos.M68kSize        =    0;
  664.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  665. //    MyCaos.PPCStart        =    NULL;
  666. //    MyCaos.PPCSize        =    0;
  667.     MyCaos.d0        =(ULONG) character;
  668.     MyCaos.caos_Un.Offset    =    (-174);
  669.     MyCaos.a6        =(ULONG) UtilityBase;    
  670.     return((UBYTE)PPCCallOS(&MyCaos));
  671. }
  672.  
  673. #define    UDivMod32(dividend, divisor)    _UDivMod32(UTILITY_BASE_NAME, dividend, divisor)
  674.  
  675. static __inline ULONG
  676. _UDivMod32(void *UtilityBase, unsigned long dividend, unsigned long divisor)
  677. {
  678. struct Caos    MyCaos;
  679.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  680. //    MyCaos.M68kStart    =    NULL;
  681. //    MyCaos.M68kSize        =    0;
  682.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  683. //    MyCaos.PPCStart        =    NULL;
  684. //    MyCaos.PPCSize        =    0;
  685.     MyCaos.d0        =(ULONG) dividend;
  686.     MyCaos.d1        =(ULONG) divisor;
  687.     MyCaos.caos_Un.Offset    =    (-156);
  688.     MyCaos.a6        =(ULONG) UtilityBase;    
  689.     return((ULONG)PPCCallOS(&MyCaos));
  690. }
  691.  
  692. #define    UMult32(arg1, arg2)    _UMult32(UTILITY_BASE_NAME, arg1, arg2)
  693.  
  694. static __inline ULONG
  695. _UMult32(void *UtilityBase, unsigned long arg1, unsigned long arg2)
  696. {
  697. struct Caos    MyCaos;
  698.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  699. //    MyCaos.M68kStart    =    NULL;
  700. //    MyCaos.M68kSize        =    0;
  701.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  702. //    MyCaos.PPCStart        =    NULL;
  703. //    MyCaos.PPCSize        =    0;
  704.     MyCaos.d0        =(ULONG) arg1;
  705.     MyCaos.d1        =(ULONG) arg2;
  706.     MyCaos.caos_Un.Offset    =    (-144);
  707.     MyCaos.a6        =(ULONG) UtilityBase;    
  708.     return((ULONG)PPCCallOS(&MyCaos));
  709. }
  710.  
  711. #define    UMult64(arg1, arg2)    _UMult64(UTILITY_BASE_NAME, arg1, arg2)
  712.  
  713. static __inline ULONG
  714. _UMult64(void *UtilityBase, unsigned long arg1, unsigned long arg2)
  715. {
  716. struct Caos    MyCaos;
  717.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  718. //    MyCaos.M68kStart    =    NULL;
  719. //    MyCaos.M68kSize        =    0;
  720.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  721. //    MyCaos.PPCStart        =    NULL;
  722. //    MyCaos.PPCSize        =    0;
  723.     MyCaos.d0        =(ULONG) arg1;
  724.     MyCaos.d1        =(ULONG) arg2;
  725.     MyCaos.caos_Un.Offset    =    (-204);
  726.     MyCaos.a6        =(ULONG) UtilityBase;    
  727.     return((ULONG)PPCCallOS(&MyCaos));
  728. }
  729.  
  730. #define    UnpackStructureTags(pack, packTable, tagList)    _UnpackStructureTags(UTILITY_BASE_NAME, pack, packTable, tagList)
  731.  
  732. static __inline ULONG
  733. _UnpackStructureTags(void *UtilityBase, APTR pack, ULONG *packTable, struct TagItem *tagList)
  734. {
  735. struct Caos    MyCaos;
  736.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  737. //    MyCaos.M68kStart    =    NULL;
  738. //    MyCaos.M68kSize        =    0;
  739.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  740. //    MyCaos.PPCStart        =    NULL;
  741. //    MyCaos.PPCSize        =    0;
  742.     MyCaos.a0        =(ULONG) pack;
  743.     MyCaos.a1        =(ULONG) packTable;
  744.     MyCaos.a2        =(ULONG) tagList;
  745.     MyCaos.caos_Un.Offset    =    (-216);
  746.     MyCaos.a6        =(ULONG) UtilityBase;    
  747.     return((ULONG)PPCCallOS(&MyCaos));
  748. }
  749.  
  750. #endif /* SASC Pragmas */
  751. #endif /* !_PPCPRAGMA_UTILITY_H */
  752.